home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / net / ds5000.md / netLEInt.h < prev    next >
C/C++ Source or Header  |  1992-12-18  |  17KB  |  466 lines
  1. /*
  2.  * netLEInt.h --
  3.  *
  4.  *    External definitions for the Am7990 (LANCE) ethernet controller.
  5.  * The description of the definitions here come from AMD Am7990 LANCE
  6.  * data sheet (Publication 05698 Rev B) and the Am7990 Techincal Manual.
  7.  
  8.  * Copyright 1988 Regents of the University of California
  9.  * Permission to use, copy, modify, and distribute this
  10.  * software and its documentation for any purpose and without
  11.  * fee is hereby granted, provided that the above copyright
  12.  * notice appear in all copies.  The University of California
  13.  * makes no representations about the suitability of this
  14.  * software for any purpose.  It is provided "as is" without
  15.  * express or implied warranty.
  16.  *
  17.  * $Header: /cdrom/src/kernel/Cvsroot/kernel/net/ds5000.md/netLEInt.h,v 9.9 92/05/13 14:45:33 jhh Exp $ SPRITE (Berkeley)
  18.  */
  19.  
  20. #ifndef _NETLEINT
  21. #define _NETLEINT
  22.  
  23. #include <netInt.h>
  24. #include <mach.h>
  25. #include <netLEMachInt.h>
  26.  
  27. /*
  28.  * Defined constants:
  29.  *
  30.  * NET_LE_NUM_RECV_BUFFERS      The number of buffers that we have to receive
  31.  *                   packets in. Also, number of receive ring 
  32.  *                descriptors. It must be between 1 and 128 and
  33.  *                be a power of TWO.
  34.  * NET_LE_NUM_RECV_BUFFERS_LOG2    log base 2 of NET_LE_NUM_RECV_BUFFERS.
  35.  * NET_LE_NUM_XMIT_BUFFERS      The number of buffer descriptors that are used
  36.  *                   for a transmitted packet.  Also, number of xmit
  37.  *                ring descriptors. It must be between 1 and 
  38.  *                128 and    be a power of TWO.
  39.  * NET_LE_NUM_XMIT_BUFFERS_LOG2    log base 2 of NET_LE_NUM_XMIT_BUFFERS.
  40.  * NET_LE_RECV_BUFFER_SIZE      The size of each receive buffer. We make the
  41.  *                buffer big enough to hold the maximum size
  42.  *                ethernet packet + CRC check. This is 1514 +
  43.  *                4 = 1518 bytes. We round it to the nears 1/2 K
  44.  *                boundry to get 1536.
  45.  *            
  46.  * NET_LE_MIN_FIRST_BUFFER_SIZE    The smallest buffer that can be used for the
  47.  *                first element of a chain transmission.
  48.  *                If the first piece of a message is smaller than  *                this then it gets copied to other storage and
  49.  *                made the minimum size.
  50.  * NET_LE_NUM_XMIT_ELEMENTS     The number of elements to preallocate for the 
  51.  *                   retransmission queue.
  52.  */
  53.  
  54. #define    NET_LE_NUM_RECV_BUFFERS_LOG2    4
  55. #define    NET_LE_NUM_RECV_BUFFERS        (1 << NET_LE_NUM_RECV_BUFFERS_LOG2)
  56.  
  57. #define    NET_LE_NUM_XMIT_BUFFERS_LOG2    5
  58. #define    NET_LE_NUM_XMIT_BUFFERS        (1 << NET_LE_NUM_XMIT_BUFFERS_LOG2)
  59.  
  60.  
  61. #define    NET_LE_RECV_BUFFER_SIZE        1536
  62. #define NET_LE_MIN_FIRST_BUFFER_SIZE    100
  63.  
  64. #define    NET_LE_NUM_XMIT_ELEMENTS    32
  65.  
  66. /*
  67.  * The LANCE chip has four control and status registers that are selected by a
  68.  * register address port (RAP) register. The top 14 bits of RAP are reserved
  69.  * and read as zeros. The register accessable in the register data port (RDP)
  70.  * is selected by the value of the RAP. (page 15)
  71.  *
  72.  */
  73.  
  74. typedef NetLEMach_Reg NetLE_Reg;
  75.  
  76. #define AddrPort    0x0e02
  77. #define DataCSR0    0x0010
  78. #define DataCSR1    0x0010
  79. #define DataCSR2    0x0808
  80. #define DataCSR3    0x0d03
  81.  
  82. /*
  83.  * Possible RAP values. (page15)
  84.  */ 
  85.  
  86. #define    NET_LE_CSR0_ADDR    0x0
  87. #define    NET_LE_CSR1_ADDR    0x1
  88. #define    NET_LE_CSR2_ADDR    0x2
  89. #define    NET_LE_CSR3_ADDR    0x3
  90.  
  91. /*
  92.  * Control and status register defintions.
  93.  *
  94.  * CSR0 - Register 0.
  95.  * Note that CSR0 is updated by ORing the previous and present value.
  96.  * See (page 16-17) for description of these bits.
  97.  * Bits of CSR0 fall into the following groups:
  98.  * (R0) - Read only - writing does nothing.
  99.  * (RC)    - Read and clear by writing a one - Writing zero does nothing.
  100.  * (RW) - Read and Write.
  101.  * (RW1) - Read and write with one only. 
  102.  */
  103.  
  104. /*
  105.  * Error bits
  106.  * NET_LE_CSR0_ERROR = BABBLE|COLLISION_ERROR|MISSED_PACKET|MEMORY_ERROR
  107.  */
  108.  
  109. #define    NET_LE_CSR0_ERROR        0x8000    /* Error summary - R0 */
  110. #define    NET_LE_CSR0_BABBLE        0x4000    /* Transmitter babble - RC */
  111. #define    NET_LE_CSR0_COLLISION_ERROR    0x2000    /* Late collision - RC */
  112. #define    NET_LE_CSR0_MISSED_PACKET    0x1000    /* Miss a packet - RC */
  113. #define    NET_LE_CSR0_MEMORY_ERROR    0x0800    /* Memory error - RC */
  114. /*
  115.  * Interrupt bits.
  116.  * NET_LE_CSR_INTR = RECV_INTR|XMIT_INTR|INIT_DONE|ERROR
  117.  */
  118. #define    NET_LE_CSR0_RECV_INTR        0x0400     /* Receiver interrupt - RC */
  119. #define    NET_LE_CSR0_XMIT_INTR        0x0200    /* Trasmit interrupt - RC */
  120. #define    NET_LE_CSR0_INIT_DONE        0x0100    /* Initialization done - RC */
  121. #define    NET_LE_CSR0_INTR        0x0080    /* Interrupt Summary - R0 */
  122. /*
  123.  * Enable bits.
  124.  */
  125. #define    NET_LE_CSR0_INTR_ENABLE        0x0040    /* Interrupt enable - RW */
  126. #define    NET_LE_CSR0_RECV_ON        0x0020    /* Receiver on - R0 */
  127. #define    NET_LE_CSR0_XMIT_ON        0x0010    /* Transmitter on - R0 */
  128. #define    NET_LE_CSR0_XMIT_DEMAND        0x0008    /* Sent now flag. - RW1 */
  129. #define    NET_LE_CSR0_STOP        0x0004    /* Stop and reset - RW1 */
  130. #define    NET_LE_CSR0_START        0x0002    /* (Re)Start after stop - RW1*/
  131. #define    NET_LE_CSR0_INIT        0x0001    /* Initialize - RW1 */
  132.  
  133. /*
  134.  * Control and status register 1 (CSR1) (page 18)
  135.  * CSR1 is the low order 16 bits of the address of the Initialization block.
  136.  * Note that the LSB must be zero.
  137.  */
  138.  
  139. /*
  140.  * Control and status register (CSR2) (page 18)
  141.  * CSR2 is the high order 16 bits of address of the Initialization block.
  142.  * Note that the top 8 bits are reserved and must be zero.
  143.  */
  144.  
  145. /*
  146.  * Control and status register (CSR3) (page 18)
  147.  * CSR3 defines the Bus Master interface.
  148.  */
  149. #define    NET_LE_CSR3_BYTE_SWAP        0x0004    /* Byte swap for us. - RW */
  150. #define    NET_LE_CSR3_ALE_CONTROL        0x0002    /* Signals active low - RW */
  151. #define    NET_LE_CSR3_BYTE_CONTROL    0x0001    /* Byte control - RW */
  152.  
  153. /*
  154.  * Define the value for csr3 for the different machine types.
  155.  */
  156. #if defined(sun4c)
  157. #define NET_LE_CSR3_VALUE \
  158.     (NET_LE_CSR3_BYTE_SWAP | NET_LE_CSR3_ALE_CONTROL | NET_LE_CSR3_BYTE_CONTROL)
  159. #else 
  160.  
  161. #if defined(ds5000)
  162. #define NET_LE_CSR3_VALUE  0
  163. #else
  164. #define NET_LE_CSR3_VALUE NET_LE_CSR3_BYTE_SWAP
  165. #endif
  166.  
  167. #endif
  168.  
  169. /*
  170.  * First in the mode register.
  171.  *
  172.  *typedef struct NetLEModeReg {
  173.  *    unsigned int    promiscuous    :1;    Read all incoing packets.  
  174.  *    unsigned int            :8;    Reserved  
  175.  *    unsigned int        internalLoop    :1;    Internal if lookBack.  
  176.  *    unsigned int    disableRetry    :1;    Disable collision retry.  
  177.  *    unsigned int    forceCollision    :1;    Force collision.     
  178.  *    unsigned int    disableCRC    :1;    Disable transmit CRC.  
  179.  *    unsigned int    loopBack    :1;    Loop back mode.  
  180.  *    unsigned int    disableXmit    :1;    Disable the transmitter.  
  181.  *    unsigned int    disableRecv    :1;    Disable the receiver.  
  182.  *} NetLEModeReg;
  183.  */
  184.  
  185. typedef unsigned short NetLEModeReg[1];
  186.  
  187. #define Promiscuous               0x0001
  188. #define InternalLoop              0x0901
  189. #define DisableRetry              0x0a01
  190. #define ForceCollision            0x0b01
  191. #define DisableCRC                0x0c01
  192. #define LoopBack                  0x0d01
  193. #define DisableXmit               0x0e01
  194. #define DisableRecv               0x0f01
  195.  
  196.  
  197. /*
  198.  *  Descriptor Ring Pointer (page 21) (Byte swapped. )
  199.  *
  200.  *typedef struct NetLERingPointer {
  201.  *    unsigned short    ringAddrLow    :16;      Low order ring address.
  202.  *                         * Must be quad word aligned. 
  203.  *                          
  204.  *    unsigned int    logRingLength    :3;      log2 of ring length.  
  205.  *    unsigned int            :5;      Reserved  
  206.  *    unsigned int    ringAddrHigh    :8;      High order ring address.  
  207.  *} NetLERingPointer;
  208.  */
  209.  
  210. typedef unsigned short NetLERingPointer[2];
  211.  
  212. #define RingAddrLow               0x0010
  213. #define LogRingLength             0x1003
  214. #define RingAddrHigh              0x1808
  215.  
  216. /*
  217.  * LE Initialization block. (Page 19)
  218.  */
  219.  
  220. typedef struct NetLEInitBlock {
  221.     NetLEModeReg    mode;            /* Mode register */
  222.     /*
  223.      * It looks like the ethernet address needs to be byte swapped.
  224.      * Also, lowest-order bit must be zero.
  225.      */
  226.     Net_EtherAddress    etherAddress;        /* The ethernet address. */
  227.     unsigned short    multiCastFilter[4];    /* Logical address filter. */
  228.     NetLERingPointer    recvRing;        /* Receive ring buffers. */
  229.     NetLERingPointer    xmitRing;        /* Transmit ring buffers. */
  230. } NetLEInitBlock;
  231.  
  232. /*
  233.  * LE Net Recv messages descriptors
  234.  * 
  235.  * typedef struct NetLERecvMsgDesc {
  236.  *     unsigned short    bufAddrLow;      Low order 16 addr bits of buffer.  
  237.  *     unsigned int    chipOwned    :1;      Buffer is owned by LANCE.  
  238.  *     unsigned int    error        :1;      Error summary  
  239.  *     unsigned int    framingError    :1;      Framing Error occured.   
  240.  *     unsigned int    overflowError    :1;      Packet overflowed.  
  241.  *     unsigned int    crcError    :1;      CRC error.  
  242.  *     unsigned int    bufferError    :1;      Buffer error.  
  243.  *     unsigned int    startOfPacket    :1;      First buffer of packet.  
  244.  *     unsigned int    endOfPacket    :1;      Last buffer of packet.  
  245.  *     unsigned char    bufAddrHigh;      High order 8 addr bits of buffer.  
  246.  *     short            bufferSize;      Size of buffer in bytes. This 
  247.  *                      * has to be the 2's complement of
  248.  *                      * the buffer size.
  249.  *                       
  250.  *     short    packetSize;          Size of the packet (bytes).  
  251.  * } NetLERecvMsgDesc;
  252.  */
  253.  
  254. typedef struct NetLERecvMsgDesc {
  255.     unsigned short    bufAddrLow;    /* Low order 16 addr bits of buffer. */
  256. #ifdef ds5000
  257.     unsigned char    bufAddrHigh;    /* High order 8 addr bits of buffer. */
  258.     unsigned char    bits[1];    /* Control bits. */
  259. #else
  260.     unsigned char    bits[1];    /* Control bits. */
  261.     unsigned char    bufAddrHigh;    /* High order 8 addr bits of buffer. */
  262. #endif
  263.     short            bufferSize;    /* Size of buffer in bytes. This 
  264.                      * has to be the 2's complement of
  265.                      * the buffer size.
  266.                      */
  267.     short    packetSize;        /* Size of the packet (bytes). */
  268. } NetLERecvMsgDesc;
  269.  
  270. #define ChipOwned                 0x0001
  271. #define Error                     0x0101
  272. #define FramingError              0x0201
  273. #define OverflowError             0x0301
  274. #define CrcError                  0x0401
  275. #define RecvBufferError           0x0501
  276. #define StartOfPacket             0x0601
  277. #define EndOfPacket               0x0701
  278.  
  279. /*
  280.  * LE Net Xmit messages descriptors (page 23-23)
  281.  * 
  282.  * typedef struct NetLEXmitMsgDesc {
  283.  *     unsigned short  bufAddrLow;      Low order 16 addr bits of buffer. 
  284.  *     unsigned int    chipOwned        :1;      Buffer owned by the LANCE  
  285.  *     unsigned int    error        :1;      Error summary  
  286.  *     unsigned int            :1;      Reserved.   
  287.  *     unsigned int    retries        :1;      More than one retry was needed.   
  288.  *     unsigned int    oneRetry        :1;      Exactly one retry was needed.  
  289.  *     unsigned int    deferred        :1;      Transmission deferred.  
  290.  *     unsigned int    startOfPacket   :1;      First buffer of packet.  
  291.  *     unsigned int    endOfPacket     :1;      Last buffer of packet.  
  292.  *     unsigned char   bufAddrHigh;      High order 8 addr bits of buffer.  
  293.  *     short           bufferSize;      Signed size of buffer in bytes. This 
  294.  *                      * has to be the 2's complement of
  295.  *                      * the buffer size.
  296.  *                      * Note that the first buffer in a
  297.  *                      * chain must have at least 100 bytes.
  298.  *                       
  299.  *     unsigned int    bufferError        :1;      Buffering error.  
  300.  *     unsigned int    underflowError  :1;      Underflow error.  
  301.  *     unsigned int            :1;      Reserved.  
  302.  *     unsigned int    lateCollision   :1;      Late collision error.  
  303.  *     unsigned int    lostCarrier        :1;      Loss of carrier error.  
  304.  *     unsigned int    retryError        :1;      Too many collision.  
  305.  *     unsigned int    tdrCounter   :10;  Time Domain Reflectometry counter.  
  306.  * } NetLEXmitMsgDesc;
  307.  */
  308. typedef struct NetLEXmitMsgDesc {
  309.     unsigned short  bufAddrLow;    /* Low order 16 addr bits of buffer.*/
  310. #ifdef ds5000
  311.     unsigned char   bufAddrHigh;    /* High order 8 addr bits of buffer. */
  312.     unsigned char   bits1[1];    /* Control bits. See below. */
  313. #else
  314.     unsigned char   bits1[1];    /* Control bits. See below. */
  315.     unsigned char   bufAddrHigh;    /* High order 8 addr bits of buffer. */
  316. #endif
  317.     short           bufferSize;        /* Signed size of buffer in bytes. This 
  318.                      * has to be the 2's complement of
  319.                      * the buffer size.
  320.                      * Note that the first buffer in a
  321.                      * chain must have at least 100 bytes.
  322.                      */
  323.     unsigned short   bits2[1];    /* Control bits. See below. */
  324. } NetLEXmitMsgDesc;
  325.  
  326. #define ChipOwned                 0x0001
  327. #define Error                     0x0101
  328. #define Retries                   0x0301
  329. #define OneRetry                  0x0401
  330. #define Deferred                  0x0501
  331. #define StartOfPacket             0x0601
  332. #define EndOfPacket               0x0701
  333.  
  334. #define XmitBufferError           0x0001
  335. #define UnderflowError            0x0101
  336. #define LateCollision             0x0301
  337. #define LostCarrier               0x0401
  338. #define RetryError                0x0501
  339. #define TdrCounter                0x060a
  340.  
  341.  
  342.  
  343. /*
  344.  * Structure to hold all state information associated with one of these
  345.  * chips.
  346.  */
  347.  
  348. typedef struct {
  349.     volatile NetLE_Reg        *regPortPtr;    /* Port to chip's registers. */
  350.     volatile NetLEInitBlock *initBlockPtr;  /* Chip initialization block. */
  351.     /*
  352.      * Pointers for ring of receive buffers. 
  353.      */
  354.     volatile NetLERecvMsgDesc    *recvDescFirstPtr;
  355.                                             /* Ring of receive desc start.*/
  356.     volatile NetLERecvMsgDesc    *recvDescNextPtr;
  357.                                             /* Next recv desc to be filled. */
  358.     volatile NetLERecvMsgDesc    *recvDescLastPtr;
  359.                                             /* Ring of recv descriptors end. */
  360.     /*
  361.      * Pointers for ring of transmit buffers. 
  362.      */
  363.     volatile NetLEXmitMsgDesc    *xmitDescFirstPtr;
  364.                                             /* Ring of xmit descriptors start.*/
  365.     volatile NetLEXmitMsgDesc    *xmitDescNextPtr;
  366.                                             /* Next xmit desc to be filled. */
  367.     volatile NetLEXmitMsgDesc    *xmitDescLastPtr;
  368.                                             /* Ring of xmit descriptors end. */
  369.  
  370.     List_Links        xmitListHdr;    /* List of packets to be transmited. */
  371.     List_Links        *xmitList;    /* Pointer to the front of the list of
  372.                        packets to be transmited. */
  373.     List_Links        xmitFreeListHdr; /* List of unused packets. */
  374.     List_Links          *xmitFreeList;    /* Pointer to a list of unused 
  375.                        transmission queue elements. */
  376.     Boolean        transmitting;    /* Set if are currently transmitting a
  377.                        packet. */
  378.     Boolean        running;    /* Is the chip currently active. */
  379.     Net_EtherAddress    etherAddressBackward;    /* The ethernet address in 
  380.                          * reverse byte order. */
  381.     Net_EtherAddress    etherAddress;    /* The ethernet address */
  382.     Address        recvDataBuffer[NET_LE_NUM_RECV_BUFFERS]; /* Receive
  383.                             * data buffers. */
  384.     Boolean        recvMemInitialized;    /* Flag for initializing
  385.                          * kernel memory. */
  386.     Boolean        recvMemAllocated;    /* Flag for allocating
  387.                          * memory for ring buffers. */
  388.     Net_ScatterGather     *curScatGathPtr;  /* Pointer to scatter gather element 
  389.                        * for current packet being sent. */
  390.     char                loopBackBuffer[NET_ETHER_MAX_BYTES]; /* Buffer for the
  391.                           * loopback address. */
  392.     char        *firstDataBuffer; /* Buffer used to ensure that
  393.                        * first element is of a minimum
  394.                        * size. */
  395.     Boolean        xmitMemInitialized; /* Flag to note if xmit memory
  396.                          * has been initialized. */
  397.     Boolean        xmitMemAllocated; /* Flag to note if xmit memory
  398.                        * has been allocated. */
  399.     Net_Interface    *interPtr;    /* Pointer back to network interface. */
  400.     Net_EtherStats    stats;        /* Performance statistics. */
  401.     int            numResets;    /* Number of times the chip has
  402.                      * been reset. */
  403.     Boolean        resetPending;    /* TRUE => chip should be reset when
  404.                      * current transmit is done. */
  405.     int            lastRecvCnt;    /* Number of packets done during
  406.                      * last receive interrupt. */
  407.     int            lateCollisions;    /* Number of transmit late collision
  408.                      * errors. */
  409. #ifdef ds5000
  410.     char        *bufAddr;    /* Network buffer. */
  411.     char        *bufAllocPtr;    /* Current allocation address in
  412.                      * network buffer. */
  413.     int            bufSize;    /* Size of the network buffer. */
  414. #endif
  415. } NetLEState;
  416.  
  417.  
  418. /*
  419.  * General routines.
  420.  */
  421.  
  422. extern    ReturnStatus    NetLEInit _ARGS_((Net_Interface *interPtr));
  423. extern    ReturnStatus    NetLEOutput _ARGS_((Net_Interface *interPtr,
  424.                 Address hdrPtr,Net_ScatterGather *scatterGatherPtr,
  425.                 int scatterGatherLength, Boolean rpc,
  426.                 ReturnStatus *statusPtr));
  427. extern    void        NetLEIntr _ARGS_((Net_Interface *interPtr, 
  428.                 Boolean polling));
  429. extern ReturnStatus     NetLEIOControl _ARGS_((Net_Interface *interPtr, 
  430.                 Fs_IOCParam *ioctlPtr, Fs_IOReply *replyPtr));
  431. extern    void        NetLERestart _ARGS_((Net_Interface *interPtr));
  432. extern    void        NetLEReset _ARGS_((Net_Interface *interPtr));
  433. extern    ReturnStatus    NetLEGetStats _ARGS_((Net_Interface *interPtr, 
  434.                 Net_Stats *statPtr));
  435. extern Address        NetLEMemAlloc _ARGS_((NetLEState *statePtr, 
  436.                 int numBytes));
  437. extern    ReturnStatus    NetLEMachInit _ARGS_ ((Net_Interface *interPtr,
  438.                 NetLEState *statePtr));
  439.  
  440. /*
  441.  * Routines for transmitting.
  442.  */
  443.  
  444. extern    void        NetLEXmitInit _ARGS_((NetLEState *statePtr));
  445. extern    ReturnStatus    NetLEXmitDone _ARGS_((NetLEState *statePtr));
  446. extern    void        NetLEXmitRestart _ARGS_((NetLEState *statePtr));
  447. extern    void        NetLEXmitDrop _ARGS_((NetLEState *statePtr));
  448.  
  449. /*
  450.  * Routines for the receive unit.
  451.  */
  452.  
  453. extern    void        NetLERecvInit _ARGS_((NetLEState *statePtr));
  454. extern    ReturnStatus    NetLERecvProcess _ARGS_((Boolean dropPackets,
  455.                 NetLEState *statePtr));
  456.  
  457.  
  458. extern    NetLEState    netLEDebugState;
  459. extern    NetLERecvMsgDesc netLEDebugRecv[];
  460. extern    NetLEXmitMsgDesc netLEDebugXmit[];
  461. extern    int        netLEDebugCount;
  462. extern    unsigned short    netLEDebugCsr0;
  463. extern    char        netLEDebugBuffer[];
  464.  
  465. #endif /* _NETLEINT */
  466.